/**
 * @p.md
 * 
 * InMemoryProvider 是一个内存中的持久化提供者，用于测试和开发
 */
import { PersistenceProvider } from './persistenceProvider';

/**
 * 存储项
 */
interface StorageItem {
  index: number;
  data: any;
  timestamp: number;
}

/**
 * 内存持久化提供者，用于测试和开发
 */
export class InMemoryProvider implements PersistenceProvider {
  private events: Map<string, StorageItem[]> = new Map();
  private snapshots: Map<string, StorageItem[]> = new Map();
  
  /**
   * 获取指定持久化 ID 的事件
   * @param persistenceId 持久化 ID
   * @param fromIndex 开始索引（包含）
   * @param toIndex 结束索引（包含）
   * @returns 事件数组
   */
  async getEventsByPersistenceId(persistenceId: string, fromIndex: number, toIndex: number): Promise<any[]> {
    const events = this.events.get(persistenceId) || [];
    
    // 过滤出指定范围内的事件，并返回事件数据
    return events
      .filter(e => e.index >= fromIndex && e.index <= toIndex)
      .sort((a, b) => a.index - b.index)
      .map(e => e.data);
  }
  
  /**
   * 获取指定持久化 ID 的最新快照
   * @param persistenceId 持久化 ID
   * @returns 快照数据，如果不存在则返回 null
   */
  async getSnapshotByPersistenceId(persistenceId: string): Promise<any | null> {
    const snapshots = this.snapshots.get(persistenceId) || [];
    
    // 排序快照，获取最新的一个
    const latestSnapshot = snapshots
      .sort((a, b) => b.index - a.index)
      .shift();
    
    return latestSnapshot ? latestSnapshot.data : null;
  }
  
  /**
   * 持久化事件
   * @param persistenceId 持久化 ID
   * @param eventIndex 事件索引
   * @param event 事件数据
   */
  async persistEvent(persistenceId: string, eventIndex: number, event: any): Promise<void> {
    if (!this.events.has(persistenceId)) {
      this.events.set(persistenceId, []);
    }
    
    const events = this.events.get(persistenceId)!;
    events.push({
      index: eventIndex,
      data: event,
      timestamp: Date.now()
    });
  }
  
  /**
   * 持久化快照
   * @param persistenceId 持久化 ID
   * @param snapshotIndex 快照索引
   * @param snapshot 快照数据
   */
  async persistSnapshot(persistenceId: string, snapshotIndex: number, snapshot: any): Promise<void> {
    if (!this.snapshots.has(persistenceId)) {
      this.snapshots.set(persistenceId, []);
    }
    
    const snapshots = this.snapshots.get(persistenceId)!;
    snapshots.push({
      index: snapshotIndex,
      data: snapshot,
      timestamp: Date.now()
    });
  }
  
  /**
   * 删除事件
   * @param persistenceId 持久化 ID
   * @param fromIndex 开始索引（包含）
   * @param toIndex 结束索引（包含）
   */
  async deleteEvents(persistenceId: string, fromIndex: number, toIndex: number): Promise<void> {
    if (!this.events.has(persistenceId)) {
      return;
    }
    
    const events = this.events.get(persistenceId)!;
    const filteredEvents = events.filter(e => e.index < fromIndex || e.index > toIndex);
    this.events.set(persistenceId, filteredEvents);
  }
  
  /**
   * 删除快照
   * @param persistenceId 持久化 ID
   * @param fromIndex 开始索引（包含）
   * @param toIndex 结束索引（包含）
   */
  async deleteSnapshots(persistenceId: string, fromIndex: number, toIndex: number): Promise<void> {
    if (!this.snapshots.has(persistenceId)) {
      return;
    }
    
    const snapshots = this.snapshots.get(persistenceId)!;
    const filteredSnapshots = snapshots.filter(s => s.index < fromIndex || s.index > toIndex);
    this.snapshots.set(persistenceId, filteredSnapshots);
  }
  
  /**
   * 清除所有数据
   */
  clear(): void {
    this.events.clear();
    this.snapshots.clear();
  }
} 